package com.cn.wanxi.util;

import com.cn.wanxi.model.CuisineModel;
import com.cn.wanxi.model.NewsStyleModel;
import com.cn.wanxi.model.PersonModel;
import com.cn.wanxi.servlet.Persion;

/**
 * 一個類包含哪些？
 * 类的组成部分
 * -------------反射--通过字符串得到类，可以得到类里面的所有组成部分
 * package
 * XiaoMing
 * 数据成员
 * 方法成员
 * 构造方法
 * 1.包  com.cn.wanxi.util
 * 1)国际com，国内cn，公司名wanxi，功能名util
 * 2)包命名规则：
 * 项目名全部小写
 * 包名全部小写
 * 每一個。之间都应该是一个单词，或者一个意思
 * 2.类：XiaoMing
 * 1）类名命名规则：大驼峰式命名---XiaoMing，每个单词首字母大写
 * 2）类不应该直接出现在src下面
 * 3）类名必须以包名结束（dao，model，service，servlet）UserModel，UserService
 */
public class XiaoMing {
    //    一个完整的定义属性的方式
//    权限修饰符，特征修饰符，数据类型  标识符  赋值运算符  变量值；
//    姓名
//    性别
//    民族
//    年龄
//    private（1）权限修饰符;
//    String（2）数据类型：数据成员必须指明其数据类型，Java中的数据类型分两种，基本类型和引用类型;
//    username（3）数据成员标志符：即数据成员的名字。名字要遵守Java的命名规范，最好采用名词性质的单词命名，可以由数字、字母、$、_组成，但是首字母不能是数字;
//    xiaoming（4）初值： 数据成员可以赋初值，也可不赋初值。如果不赋，则会有默认值（根据数据类型不同而不同）。
//    private String username="xiaoming"；
//    https://www.runoob.com/java/java-modifier-types.html Java基础学习资料
    /*
    1.修饰符
    权限修饰符（访问修饰符）  private,public,protected,默认不写
    特征修饰符（非访问修饰符）
    static ，修饰属性，方法
    final，
    abstract，
    synchronized，
    volatile，
    native
     */
    /*
    数据成员标志符(变量名)
    变量属性命名规则：
     小驼峰命名   首字母小写，每个单词第一个字母大写  userModel
     不允许出现特殊字符，数字下划线，拼音，混拼，中文，只允许英文
     变量的修饰符   默认private 如果需要对外提供接口  set或get方法
     */
    /*
    运算符
    算术运算符  +-*%/ ++ --
    逻辑运算符
    赋值运算符
    位运算符
    关系运算符
    三目运算符 ？：
     */
    /**
     * Java命名规范
     * 类名 大驼峰  UserModel
     * 包名  全小写  usermodel
     * 变量名  小驼峰  userModel
     *      局部变量
     *      成员变量
     *      类变量
     *      静态变量
     * 常量 全大写   USER_MODEL
     * 方法名 小驼峰  findByUsernameAndPassword  （取名要见名知意）
     */
    /**
     * Java数据类型：
     * 基本数据类型
     * 1）四种
     * 有符号位 和无符号位
     * 整型， byte   1  short   2 int   4 long  8
     * 浮点型，float  4  double  8
     * 布尔型， boolean 1个bit位
     * 字符型 char 2
     * 面试：默认值，取值访问，字节数，引用类型
     * 引用数据类型(除了基本类型)
     * 数组，集合，注解，接口，枚举，类
     */

    private String privateusername = "privatexiaoming";
    public String publicusername = "privatexiaoming";
    protected String protectedusername = "privatexiaoming";
    //    默认不写
    String username = "privatexiaoming";

    /**
     * 1.private 只能当前类可以访问
     * 2.默认不写只能当前包可以访问
     * 3.public 任何地方都可以访问
     * 4.protect  只能子孙类才能访问
     */
//    public static void main(String[] args) {
//        new XiaoMing().
//        System.out.println(privateusername);
//        byte b = -128;
//        short s = 2;
//        int i = 3;
//        long n = 4;
//        System.out.println(b=3);
//        s=b;
//        b= (byte) s;
//        向上转型和向下转型
//        自动转换和强制转换
//        装箱与拆箱  基本类型分组成引用类--装箱
//        int a=0;
//        int b=1;
//        int c=a+++++b;
//        System.out.println(a);
//        System.out.println(b);
//        System.out.println(c);
//        c=?
//        int d=0;
//        for(int i=0;i<100;i++){
//          d++;
//        d=d++;
//        d=++d;
//        ++d;
//        }
//        System.out.println(d);
//        d=？；
//        int a = 0;
//        byte b = 1;
//        b=a+1;
//        b=b+1;
//        b += 1;//默認强制转换
//       if( false && true){
//       }
//        instanceof 运算符   判断当前数据类型是否为子类型
//        js typeof  返回当前数据类型

    /**
     * 类的组成部分？
     * 1.包
     * 2.类名
     * -----------命名规范
     * 3.属性
     * ------ 一个完整的定义  ---- 数据类型？
     * ----- 修饰符  权限修饰符  特征修饰符
     * 4.方法
     * 5.构造方法
     */
//    XiaoMing xiaoMing = new XiaoMing();
//    XiaoMing xiaoMing1 = new XiaoMing();
//    XiaoMing xiaoMing2 = new XiaoMing();
//    }

    // 权限修饰符只能放在类变量和类名 --
    private static String nam = "a";
    private String aaname = new String("b");

    public static void main(String[] args) {


//        String a = "1";
//        String b = "1";
//        String c = new String("1");
//        String d = new String("1");
//    指针
//        System.out.println(a == b);
//        System.out.println(a.equals(b));
//        System.out.println(a == c);
//        System.out.println(a.equals(c));
//        System.out.println(d == c);
//        System.out.println(d.equals(c));
//    判断  a==b;
//    a.equals(b);
//    a==c;
//    a.equals(c),
//    d==c,
//    d.equals(c)
        System.out.println("主方法");
        new XiaoMing();
        /**
         * 只要加载当前类 都会执行静态代码块
         * 只要实例化对象  才会加载代码块和构造方法
         * 执行顺序  静态代码块  ---代码块 ---构造方法
         * 静态代码块是按照书写顺序执行
         */
    }
/**
 * static  修饰类方法和类属性
 *  静态变量也被称为类变量
 *  类变量不一定是静态变量
 *  局部变量不能被声明为 static 变量。
 *  全局变量
 *  局部变量
 *  类变量
 *  静态变量
 *  常量
 */
    /**
     * 一个完整的方法定义
     * 权限修饰符  特征修饰符  返回值类型  方法名（参数类型 参数名...） 异常
     * {
     * 方法体
     * return 返回值;
     * }
     */
//    void 表示方法没有返回值
//    如果我们方法名和类名一样，没有其他修饰符参与，则当前方法位构造方法
// 方法名命名规范  小驼峰  见名知意
//    代码块
//    静态代码块
//    构造方法有返回值
    XiaoMing() {
        System.out.println("构造方法");
    }


    {
        System.out.println("代码块");
        new PersonModel().eat();
    }

    static Parent parent = new Parent();

    static {
        System.out.println("静态代码块");
    }
    /**
     * 类与类之间的关系？
     */
    /**
     * 实践操作：
     * servlet框架+jsp模板
     * 后台框架：分层
     * 三层架构
     * 服务逻辑层 service 封装逻辑算法 结构
     * 数据实现层 dao  存取数据
     * 业务控制层 servlet （页面控制层）和页面打交道
     * 对象实体层  model(pojo VO,DO,TO DTO)  所有对象封装 只写属性
     * 工具层   util  所有公共的类
     * ---------------------------------------
     * 1.封装model   找寻页面相关的对象   最小对象
     * 2.数据层
     * 3.编写jsp页面
     * 4.页面控制层  所有的页面数据必须通过Java后台得到
     *    所有访问Java后台必须通过服务器去访问？tomcat容器
     *    不能之间访问页面，二应该通过后台取值，所以需要给前端一个接口地址（api）
     * 5.service 需要将所有逻辑代码提取出来放在服务逻辑层
     */
}
